@workglow/ai 0.0.57 → 0.0.59

package/README.md

@@ -32,9 +32,11 @@ import {
   setGlobalModelRepository,
   InMemoryModelRepository,
   AiJob,
+  AiJobInput,
 } from "@workglow/ai";
-import { Workflow, getTaskQueueRegistry } from "@workglow/task-graph";
-import { JobQueue } from "@workglow/job-queue";
+import { Workflow, getTaskQueueRegistry, TaskInput, TaskOutput } from "@workglow/task-graph";
+import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
+import { InMemoryQueueStorage } from "@workglow/storage";
 import { HF_TRANSFORMERS_ONNX, register_HFT_InlineJobFns } from "@workglow/ai-provider";
 
 // 1. Set up a model repository
@@ -59,7 +61,23 @@ await modelRepo.connectTaskToModel("TextGenerationTask", "onnx:Xenova/LaMini-Fla
 await register_HFT_InlineJobFns();
 
 // 5. Set up job queue for the provider
-getTaskQueueRegistry().registerQueue(new JobQueue(HF_TRANSFORMERS_ONNX, AiJob));
+const queueName = HF_TRANSFORMERS_ONNX;
+const storage = new InMemoryQueueStorage<AiJobInput<TaskInput>, TaskOutput>(queueName);
+
+const server = new JobQueueServer<AiJobInput<TaskInput>, TaskOutput>(AiJob, {
+  storage,
+  queueName,
+  limiter: new ConcurrencyLimiter(1),
+});
+
+const client = new JobQueueClient<AiJobInput<TaskInput>, TaskOutput>({
+  storage,
+  queueName,
+});
+
+client.attach(server);
+getTaskQueueRegistry().registerQueue({ server, client, storage });
+await server.start();
 
 // 6. Create and run a workflow
 const workflow = new Workflow();
@@ -122,8 +140,8 @@ import { TextTranslationTask } from "@workglow/ai";
 const task = new TextTranslationTask({
   model: "translation-model",
   text: "Hello, how are you?",
-  sourceLanguage: "en",
-  targetLanguage: "es",
+  source_lang: "en",
+  target_lang: "es",
 });
 
 const result = await task.run();
@@ -344,12 +362,29 @@ For compute-intensive tasks that should run in workers:
 Each provider needs a job queue for task execution:
 
 ```typescript
-import { getTaskQueueRegistry } from "@workglow/task-graph";
-import { JobQueue } from "@workglow/job-queue";
-import { AiJob } from "@workglow/ai";
+import { getTaskQueueRegistry, TaskInput, TaskOutput } from "@workglow/task-graph";
+import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
+import { InMemoryQueueStorage } from "@workglow/storage";
+import { AiJob, AiJobInput } from "@workglow/ai";
 import { HF_TRANSFORMERS_ONNX } from "@workglow/ai-provider";
 
-getTaskQueueRegistry().registerQueue(new JobQueue(HF_TRANSFORMERS_ONNX, AiJob));
+const queueName = HF_TRANSFORMERS_ONNX;
+const storage = new InMemoryQueueStorage<AiJobInput<TaskInput>, TaskOutput>(queueName);
+
+const server = new JobQueueServer<AiJobInput<TaskInput>, TaskOutput>(AiJob, {
+  storage,
+  queueName,
+  limiter: new ConcurrencyLimiter(1),
+});
+
+const client = new JobQueueClient<AiJobInput<TaskInput>, TaskOutput>({
+  storage,
+  queueName,
+});
+
+client.attach(server);
+getTaskQueueRegistry().registerQueue({ server, client, storage });
+await server.start();
 ```
 
 ## Workflow Integration

package/dist/browser.js

@@ -6,31 +6,14 @@ import {
   PermanentJobError
 } from "@workglow/job-queue";
 
-// src/model/storage/InMemoryModelRepository.ts
+// src/model/ModelRegistry.ts
+import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+
+// src/model/InMemoryModelRepository.ts
 import { InMemoryTabularRepository } from "@workglow/storage";
 
 // src/model/ModelRepository.ts
 import { EventEmitter } from "@workglow/util";
-var ModelSchema = {
-  type: "object",
-  properties: {
-    name: { type: "string" },
-    details: { type: "string" }
-  },
-  required: ["name", "details"],
-  additionalProperties: false
-};
-var ModelPrimaryKeyNames = ["name"];
-var Task2ModelSchema = {
-  type: "object",
-  properties: {
-    task: { type: "string" },
-    model: { type: "string" }
-  },
-  required: ["task", "model"],
-  additionalProperties: false
-};
-var Task2ModelPrimaryKeyNames = ["task", "model"];
 
 class ModelRepository {
   type = "ModelRepository";
@@ -48,101 +31,101 @@ class ModelRepository {
     return this.events.waitOn(name);
   }
   async addModel(model) {
-    await this.modelTabularRepository.put({ name: model.name, details: JSON.stringify(model) });
-    this.models.set(model.name, model);
+    await this.modelTabularRepository.put(model);
     this.events.emit("model_added", model);
     return model;
   }
   async findModelsByTask(task) {
     if (typeof task != "string")
       return;
-    const junctions = await this.task2ModelTabularRepository.search({ task });
-    if (!junctions || junctions.length === 0)
+    const allModels = await this.modelTabularRepository.getAll();
+    if (!allModels || allModels.length === 0)
+      return;
+    const models = allModels.filter((model) => model.tasks?.includes(task));
+    if (models.length === 0)
       return;
-    const models = [];
-    for (const junction of junctions) {
-      const model = await this.modelTabularRepository.get({ name: junction.model });
-      if (model)
-        models.push(JSON.parse(model.details));
-    }
-    models.forEach((m) => this.models.set(m.name, m));
-    this.taskModels.set(task, models);
     return models;
   }
-  models = new Map;
-  taskModels = new Map;
-  async findTasksByModel(model) {
-    if (typeof model != "string")
+  async findTasksByModel(model_id) {
+    if (typeof model_id != "string")
       return;
-    const junctions = await this.task2ModelTabularRepository.search({ model });
-    if (!junctions || junctions.length === 0)
+    const modelRecord = await this.modelTabularRepository.get({ model_id });
+    if (!modelRecord)
       return;
-    return junctions.map((junction) => junction.task);
+    return modelRecord.tasks && modelRecord.tasks.length > 0 ? modelRecord.tasks : undefined;
   }
   async enumerateAllTasks() {
-    const junctions = await this.task2ModelTabularRepository.getAll();
-    if (!junctions || junctions.length === 0)
+    const allModels = await this.modelTabularRepository.getAll();
+    if (!allModels || allModels.length === 0)
       return;
-    const uniqueTasks = [...new Set(junctions.map((junction) => junction.task))];
-    return uniqueTasks;
+    const uniqueTasks = new Set;
+    for (const model of allModels) {
+      if (model.tasks) {
+        for (const task of model.tasks) {
+          uniqueTasks.add(task);
+        }
+      }
+    }
+    return uniqueTasks.size > 0 ? Array.from(uniqueTasks) : undefined;
   }
   async enumerateAllModels() {
     const models = await this.modelTabularRepository.getAll();
     if (!models || models.length === 0)
       return;
-    const parsedModels = models.map((model) => JSON.parse(model.details));
-    parsedModels.forEach((m) => this.models.set(m.name, m));
-    return parsedModels;
-  }
-  async connectTaskToModel(task, model) {
-    await this.task2ModelTabularRepository.put({ task, model });
-    this.events.emit("task_model_connected", task, model);
+    return models;
   }
-  async findByName(name) {
-    if (typeof name != "string")
+  async findByName(model_id) {
+    if (typeof model_id != "string")
       return;
-    const modelstr = await this.modelTabularRepository.get({ name });
-    if (!modelstr)
-      return;
-    const model = JSON.parse(modelstr.details);
-    this.models.set(model.name, model);
-    return model;
+    const model = await this.modelTabularRepository.get({ model_id });
+    return model ?? undefined;
   }
   async size() {
     return await this.modelTabularRepository.size();
   }
-  async clear() {
-    await this.modelTabularRepository.deleteAll();
-  }
 }
 
-// src/model/storage/InMemoryModelRepository.ts
+// src/model/ModelSchema.ts
+var ModelSchema = {
+  type: "object",
+  properties: {
+    model_id: { type: "string" },
+    tasks: { type: "array", items: { type: "string" } },
+    title: { type: "string" },
+    description: { type: "string" },
+    provider: { type: "string" },
+    providerConfig: { type: "object", default: {} },
+    metadata: { type: "object", default: {} }
+  },
+  required: ["model_id", "tasks", "provider", "title", "description", "providerConfig", "metadata"],
+  additionalProperties: false
+};
+var ModelPrimaryKeyNames = ["model_id"];
+
+// src/model/InMemoryModelRepository.ts
 class InMemoryModelRepository extends ModelRepository {
   modelTabularRepository;
-  task2ModelTabularRepository;
   type = "InMemoryModelRepository";
   constructor() {
     super();
     this.modelTabularRepository = new InMemoryTabularRepository(ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new InMemoryTabularRepository(Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
   }
 }
 
 // src/model/ModelRegistry.ts
-class FallbackModelRegistry extends InMemoryModelRepository {
+var MODEL_REPOSITORY = createServiceToken("model.repository");
+if (!globalServiceRegistry.has(MODEL_REPOSITORY)) {
+  globalServiceRegistry.register(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
 }
-var modelRegistry;
 function getGlobalModelRepository() {
-  if (!modelRegistry)
-    modelRegistry = new FallbackModelRegistry;
-  return modelRegistry;
+  return globalServiceRegistry.get(MODEL_REPOSITORY);
 }
 function setGlobalModelRepository(pr) {
-  modelRegistry = pr;
+  globalServiceRegistry.registerInstance(MODEL_REPOSITORY, pr);
 }
 
 // src/provider/AiProviderRegistry.ts
-import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util";
+import { globalServiceRegistry as globalServiceRegistry2, WORKER_MANAGER } from "@workglow/util";
 
 class AiProviderRegistry {
   runFnRegistry = new Map;
@@ -154,7 +137,7 @@ class AiProviderRegistry {
   }
   registerAsWorkerRunFn(modelProvider, taskType) {
     const workerFn = async (input, model, update_progress, signal) => {
-      const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
+      const workerManager = globalServiceRegistry2.get(WORKER_MANAGER);
       const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model], {
         signal,
         onProgress: update_progress
@@ -475,25 +458,29 @@ class AiTask extends JobQueueTask {
     config.name ||= `${new.target.type || new.target.name}${input.model ? " with model " + input.model : ""}`;
     super(input, config);
   }
-  async createJob(input, queue) {
+  async getJobInput(input) {
     if (typeof input.model !== "string") {
       console.error("AiTask: Model is not a string", input);
       throw new TaskConfigurationError("AiTask: Model is not a string, only create job for single model tasks");
     }
     const runtype = this.constructor.runtype ?? this.constructor.type;
     const model = await this.getModelForInput(input);
-    const queueName = queue?.queueName ?? await this.getDefaultQueueName(input);
-    if (!queueName) {
+    return {
+      taskType: runtype,
+      aiProvider: model.provider,
+      taskInput: input
+    };
+  }
+  async createJob(input, queueName) {
+    const jobInput = await this.getJobInput(input);
+    const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
+    if (!resolvedQueueName) {
       throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
     }
     const job = new AiJob({
-      queueName,
+      queueName: resolvedQueueName,
       jobRunId: this.config.runnerId,
-      input: {
-        taskType: runtype,
-        aiProvider: model.provider,
-        taskInput: input
-      }
+      input: jobInput
     });
     return job;
   }
@@ -532,7 +519,7 @@ class AiTask extends JobQueueTask {
       for (const [key, propSchema] of modelTaskProperties) {
         let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
         for (const model of requestedModels) {
-          const foundModel = taskModels?.find((m) => m.name === model);
+          const foundModel = taskModels?.find((m) => m.model_id === model);
           if (!foundModel) {
             throw new TaskConfigurationError(`AiTask: Missing model for '${key}' named '${model}' for task '${this.type}'`);
           }
@@ -566,7 +553,7 @@ class AiTask extends JobQueueTask {
       const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
       for (const [key, propSchema] of modelTaskProperties) {
         let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
-        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.name === model));
+        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.model_id === model));
         usingModels = usingModels.length > 1 ? usingModels : usingModels[0];
         input[key] = usingModels;
       }
@@ -663,7 +650,7 @@ var TypeLanguage = (annotations = {}) => ({
   minLength: 2,
   ...annotations
 });
-function TypeModel(semantic = "model", options = {}) {
+function TypeModelAsString(semantic = "model", options = {}) {
   if (semantic !== "model" && !semantic.startsWith("model:")) {
     throw new Error("Invalid semantic value");
   }
@@ -676,6 +663,11 @@ function TypeModel(semantic = "model", options = {}) {
     type: "string"
   };
 }
+function TypeModel(semantic = "model", options = {}) {
+  return {
+    oneOf: [TypeModelAsString(semantic, options), ModelSchema]
+  };
+}
 var TypeReplicateArray = (type, annotations = {}) => ({
   oneOf: [type, { type: "array", items: type }],
   title: type.title,
@@ -1117,11 +1109,15 @@ var TextTranslationInputSchema = {
     }),
     source_lang: TypeReplicateArray(TypeLanguage({
       title: "Source Language",
-      description: "The source language"
+      description: "The source language",
+      minLength: 2,
+      maxLength: 2
     })),
     target_lang: TypeReplicateArray(TypeLanguage({
       title: "Target Language",
-      description: "The target language"
+      description: "The target language",
+      minLength: 2,
+      maxLength: 2
     })),
     model: modelSchema7
   },
@@ -1138,7 +1134,9 @@ var TextTranslationOutputSchema = {
     },
     target_lang: TypeLanguage({
       title: "Output Language",
-      description: "The output language"
+      description: "The output language",
+      minLength: 2,
+      maxLength: 2
     })
   },
   required: ["text", "target_lang"],
@@ -1293,18 +1291,6 @@ function normalize(vector) {
   }
   return new Float32Array(normalized);
 }
-// src/model/storage/IndexedDbModelRepository.ts
-import { IndexedDbTabularRepository } from "@workglow/storage";
-class IndexedDbModelRepository extends ModelRepository {
-  modelTabularRepository;
-  task2ModelTabularRepository;
-  type = "IndexedDbModelRepository";
-  constructor(tableModels = "models", tableTask2Models = "task2models") {
-    super();
-    this.modelTabularRepository = new IndexedDbTabularRepository(tableModels, ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new IndexedDbTabularRepository(tableTask2Models, Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
-  }
-}
 export {
   setGlobalModelRepository,
   setAiProviderRegistry,
@@ -1316,6 +1302,7 @@ export {
   VectorSimilarityTask,
   TypedArraySchema,
   TypeReplicateArray,
+  TypeModelAsString,
   TypeModel,
   TypeLanguage,
   TextTranslationTask,
@@ -1343,15 +1330,13 @@ export {
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
   TextEmbedding,
-  Task2ModelSchema,
-  Task2ModelPrimaryKeyNames,
   TableFragment,
   SimilarityFn,
   Similarity,
   ModelSchema,
   ModelRepository,
   ModelPrimaryKeyNames,
-  IndexedDbModelRepository,
+  MODEL_REPOSITORY,
   InMemoryModelRepository,
   ImageFragment,
   DownloadModelTask,
@@ -1368,4 +1353,4 @@ export {
   AiJob
 };
 
-//# debugId=CB10B0DB935086A564756E2164756E21
+//# debugId=55D3E7D54413645E64756E2164756E21